<?php
App::uses('AppController', 'Controller');
App::uses('Sanitize', 'Utility');
/**
 * Editions Controller
 *
 * @property Edition $Edition
 * @property PaginatorComponent $Paginator
 * @property SessionComponent $Session
 */
class EditionsController extends AppController {

/**
 * Components
 *
 * @var array
 */
	// public $components = array('Paginator', 'Session');
	public $components = array(
		'Paginator', 'Session','Cookie',
		'Auth' => array(
			'loginAction' => array(
				'controller' => 'utilisateurs',
				'action' => 'login'
			)
	));
	
	/* Declaration des helpers utuilisés, ici StraHelper qui permet de noter les livres */
	public $helpers = array('Star');
/**
 * Models
 *
 * @var array
 */
	public $uses = array('Livre', 'Edition','Auteur','Editeur','Exemplaire','TagsCategory','Utilisateur','StatutDemande');

/**
 * beforeFilter method
 * 
 * @return void
 */	
	public function beforeFilter()
	{
		parent::beforeFilter();
		/* fonctions autorisées sans connexion */
		$this->Auth->allow('view','index_auteur','index_category','index_utilisateur','index','index_test','noter');

	}
	
/**
 * index method
 *
 * @return void
 */
	public function index() {
		$conditions = array();
		$order=array();
		/* Si search est passé en GET dans l'url */
		if (isset($this->request->query['search'])){
			
			/* On échappe l'entrée utilisateur : non fait par CakePHP pour ce que l'on fait en-dessous */
			$search = Sanitize::escape($this->request->query['search']);
		    
			/* Est-ce que la recherche est un ISBN ? */
			$isbn = ereg_replace("[^0-9]","",$search);
			if(strlen($search) < 18 && strlen($isbn)>8) {
				$conditions = array('or' => array(
						'Edition.isbn10 LIKE' => '%'.$isbn.'%',
						'Edition.isbn13 LIKE' => '%'.$isbn.'%'
					)
				);
			} else {
				/* score est une valeur calculée par mysql qui évalue 
				   la relevance/pertinence de chaque résultat par rapport aux mots-clés fournis 
				   Pour limiter les résultats, on ne prend que les résultats avec score > 150  
				 */				
				$this->Edition->virtualFields = array(
					'score' => 'MATCH (titre,sous_titre,resume,auteurs) AGAINST (\''.$search.'\' WITH QUERY EXPANSION)'
				);					
				$conditions = array(
					'MATCH (titre,sous_titre,resume,auteurs) AGAINST ("'.$search.'" WITH QUERY EXPANSION) > 190 '
				);		
				$order = array(
					'Edition.score' => 'desc'
				);
			}

			/* Titre de la page */
			$this->set('title_page', __("Résultats pour : ".h($this->request->query['search'])));		
		} else {
			/* Titre de la page */
			$this->set('title_page', __("Découvrir"));			
		}
	


		/* On appelle la fonction index_view qui va effectuer la recherche de livres */
		$this->index_view($conditions,$order);
	}		
	
/**
 * noter method
 * reçoit une requête AJAX pour noter un livre
 * retourne au client du JSON avec erreur à non vide si qqch s'est mal passé 
 * @param string $id : l'identifiant de la categorie 
 * @return void
 */
	public function noter($edition_id) {
		
		$this->layout='ajax';
		if (!$this->Edition->exists($edition_id)) {
			echo json_encode(array('erreur'=>__("Livre inconnu.")));
		}
		if($this->Auth->login()){
			$utilidateur_id = $this->Auth->user('id');
			$exemplaire = $this->Exemplaire->find('first',array('conditions'=>array('edition_id'=>$edition_id,'utilisateur_id'=>$utilidateur_id)));
			/* Si 1 exemplaire de cette édition existe pour l'utilisateur, on l'update */
			if(!empty($exemplaire)) 
				$this->Exemplaire->id = $exemplaire['Exemplaire']['id'];
			$this->Exemplaire->save(array('note'=>$this->request->query['note'],'utilisateur_id'=>$utilidateur_id,'edition_id'=>$edition_id));
			/* Tout s'est bien passé */
			echo json_encode(array('erreur'=>""));
		} else {
			echo json_encode(array('erreur'=>__("Vous devez être connecté pour utiliser cette fonctionnalité.")));
		}
	}
	
/**
 * index_category method
 * affiche les livres d'une catégorie donnée
 * @param string $id : l'identifiant de la categorie
 * @return void
 */

	public function index_category($id) {
		
		if (!$this->TagsCategory->exists($id)) {
			throw new NotFoundException(__('Catégorie inconnue'));
		}
		
		$this->TagsCategory->recursive= -1;
		$options = array('conditions' => array('TagsCategory.' . $this->TagsCategory->primaryKey => $id));
		$category = $this->TagsCategory->find('first', $options);
		
		/* Recherche des livres qui correspondent à la catégorie demandée */
		$livres = $this->Livre->getDataSource()->fetchAll(
		'select GROUP_CONCAT(Livre.id) as livre_ids from livres Livre, livres_tags_categories LivresTagsCategory where 
			Livre.id=LivresTagsCategory.livre_id AND LivresTagsCategory.tags_category_id = :tags_category_id',
			array('tags_category_id' => $id)
		);
		
		/* Recherche des auteurs correspondant aux livres trouvés */
		$auteurs = $this->Auteur->getDataSource()->fetchAll(
		'select Auteur.id, Auteur.nombre, Auteur.prenom_nom FROM (SELECT Auteur.*, count(AuteursLivre.auteur_id) as nombre 
			FROM  auteurs Auteur, auteurs_livres AuteursLivre where Auteur.prenom_nom !="Inconnu" and AuteursLivre.auteur_id = Auteur.id 
			and AuteursLivre.auteur_id in (select distinct AuteursLivre.auteur_id from livres Livre, auteurs_livres AuteursLivre where Livre.id in ('.$livres[0][0]['livre_ids'].') and Livre.id=AuteursLivre.livre_id)
			group by AuteursLivre.auteur_id order by nombre DESC) as Auteur '
		);
		$auteur_ids = array();
		foreach($auteurs as $auteur){
			$auteur_ids[]=$auteur['Auteur']['id'];
		}
		/* Recherche des catégories associées aux auteurs trouvés */
		if($auteur_ids){
			$categories_ids = $this->TagsCategory->getDataSource()->fetchAll(
			'select GROUP_CONCAT(TagsCategory.id) as category_ids from (select distinct livres_tags_categories.tags_category_id as id, 
				tags_categories.libelle as libelle, count(livres_tags_categories.tags_category_id) as nombre from auteurs, auteurs_livres, livres_tags_categories, tags_categories where 
				auteurs.id in ('.join(',',$auteur_ids).') and auteurs_livres.auteur_id = auteurs.id 
				and auteurs_livres.livre_id = livres_tags_categories.livre_id 
				and livres_tags_categories.tags_category_id = tags_categories.id 
				group by livres_tags_categories.tags_category_id order by nombre DESC) as TagsCategory
				'
			);

			$categories_traduites = $this->TagsCategory->find('list',array(
				'fields'=>array('libelle'),
				'conditions'=>array('TagsCategory.id'=>split(',',$categories_ids[0][0]['category_ids']))
				));

			$nombre_livres_categories = $this->TagsCategory->getDataSource()->fetchAll(
			'select TagsCategory.nombre, TagsCategory.id from (select tags_categories.id as id, 
				tags_categories.libelle as libelle, count(livres_tags_categories.id) as nombre from tags_categories, livres_tags_categories where 
				tags_categories.id in ('.$categories_ids[0][0]['category_ids'].') 
				and livres_tags_categories.tags_category_id = tags_categories.id 
				group by tags_categories.id order by nombre DESC) as TagsCategory
				'
			);
			$categories = array();
			foreach($nombre_livres_categories as $cat){
				/* Si il existe une traduction de la catégorie */
				if(isset($categories_traduites[$cat['TagsCategory']['id']])){
					$cat['TagsCategory']['libelle'] = $categories_traduites[$cat['TagsCategory']['id']];
					$categories[] = $cat;
				}
			}
			// $categories = array_replace_recursive($categories,$nombre_livres_categories);
			$this->set('categories',$categories);
		}
		
		$livre_ids=split(',',$livres[0][0]['livre_ids']);

		$conditions = array(
				'Livre.id' => $livre_ids
		);
		$this->set('title_page', $category['TagsCategory']['libelle']);
		$this->set('auteurs',$auteurs);
		$this->index_view($conditions);
	}		
/**
 * index_auteur method
 * affiche tous les livres de l'auteur d'identifiant id
 * @param string $id : l'identifiant de l'auteur
 * @return void
 */
	public function index_auteur($id) {
		
		/* Si l'auteur n'existe pas on lève une exception */
		if (!$this->Auteur->exists($id)) {
			throw new NotFoundException(__('Auteur inconnu'));
		}
		
		$this->Auteur->recursive= -1;
		$options = array('conditions' => array('Auteur.' . $this->Auteur->primaryKey => $id));
		/* Recherche de l'auteur */
		$auteur = $this->Auteur->find('first', $options);
		/* Recherche des livres de l'auteur */
		$livres = $this->Livre->getDataSource()->fetchAll(
		'select GROUP_CONCAT(Livre.id) as livre_ids from livres Livre where exists 
			(select 1 from auteurs_livres t where Livre.id=t.livre_id AND t.auteur_id = (:auteur_id))',
			array('auteur_id' => $id)
		);
		/* Concaténation des id des livres */
		$livre_ids=split(',',$livres[0][0]['livre_ids']);

		$conditions = array(
				'Livre.id' => $livre_ids
		);
		
		$this->set('title_page', 'Tous les livres de '.$auteur['Auteur']['prenom_nom']);
		$this->index_view($conditions);
	}

/**
 * index_view method
 * fontion appelée après avoir constitué les conditions de recherche en amont
 * @param array $conditions : conditions de sélection des éditions
 * @param string $order : ordre dans lequel afficher les éditions
 * @return void
 */
	private function index_view($conditions,$order=""){
		if($this->Auth->login()){
			$utilidateur_id = $this->Auth->user('id');
			/* latitude de l'utilisateur */
			$latitude =  AuthComponent::user('latitude');
			/* longitude de l'utilisateur */
			$longitude =  AuthComponent::user('longitude');
			/* fragment de requete sql permettant de calculer 
			   la distance entre un exemplaire et l'utilisateur connecté */
			$distance_sql = "( 6371 * acos( cos( radians($latitude) ) * cos( radians( latitude ) ) * cos( radians(longitude ) - radians($longitude) ) + sin( radians($latitude) ) * sin( radians(latitude ) ) ) ) as `distance`";
		} else {
			$utilidateur_id = 0;
			$distance_sql = "'' as distance";
		}
			
		/* On associe l'exemplaire de l'utilisateur connecté à l'édition*/
		$this->Edition->bindModel(
			array('hasOne' => array(
					'ExemplaireUtilisateur' => array(
						'className' => 'Exemplaire',
						'conditions' => 'ExemplaireUtilisateur.utilisateur_id='.$utilidateur_id
					)
				)
			)
		);
		/* On associe 1 édition à ses exemplaires disponibles */
		$this->Edition->bindModel(
			array('hasMany' => array(
					'ExemplaireDisponible' => array(
						'className' => 'Exemplaire',
						'finderQuery' => ' SELECT ExemplaireDisponible.* from 
						(select exemplaires.*, '.$distance_sql.' from exemplaires, utilisateurs WHERE exemplaires.utilisateur_id = utilisateurs.id
							and exemplaires.edition_id in ({$__cakeID__$}) ) as ExemplaireDisponible order by ExemplaireDisponible.distance asc 
							'
					)
				)
			)
		);	
		
		/* Si $order est non vide, on le met dans les settings de Paginator 
		pour contain, on bénéficie du behavior Containable qui a été déclaré dans le model Edition.php 
		*/
		if($order){
			$this->Paginator->settings = array(
				'order' => $order,
				'recursive' => 3 ,
				'contain' => array('Exemplaire','Livre','Editeur','Livre.Auteur','ExemplaireUtilisateur','ExemplaireDisponible','ExemplaireDisponible.Utilisateur'),
				'conditions' => $conditions ,
				'limit' => 10
			);
		} else {
		/* Si $order non défini, on laisse paginator gérer */
			$this->Paginator->settings = array(
				'recursive' => 3 ,
				'contain' => array('Exemplaire','Livre','Editeur','Livre.Auteur','ExemplaireUtilisateur','ExemplaireDisponible','ExemplaireDisponible.Utilisateur'),
				'conditions' => $conditions ,
				'limit' => 10
			);
		}
		
		/* Recherche des items à mettre dans la colone de gauche dans la vue */
		if(!isset($this->viewVars['auteurs'])){
			$this->set('auteurs',$this->Auteur->getPopulaires());
		}
		if(!isset($this->viewVars['categories'])){
			$this->set('categories',$this->TagsCategory->getPopulaires());
		}
		
		$this->set('editions', $this->Paginator->paginate('Edition'));
		$this->render('index');	
	}
/**
 * index_utilisateur method
 * Affiche tous les livres d'un utilisateur
 * @param string $id : identifiant de l'utilisateur dont on veut afficher les livres 
 * @return void
 */
	public function index_utilisateur($id) {

		if (!$this->Utilisateur->exists($id)) {
			throw new NotFoundException(__('Utilisateur inconnu'));
		}	
	
		$this->Utilisateur->recursive= -1;
		$options = array('conditions' => array('Utilisateur.' . $this->Utilisateur->primaryKey => $id));
		/* Recherche de l'utilisateur */
		$utilisateur = $this->Utilisateur->find('first', $options);
		
		/* Recherche des éditions possédées par l'utilisateur */
		$editions = $this->Livre->getDataSource()->fetchAll(
		'select GROUP_CONCAT(Edition.id) as edition_ids from editions Edition, exemplaires Exemplaire where Exemplaire.edition_id = Edition.id 
		and Exemplaire.utilisateur_id = (:utilisateur_id) and Exemplaire.possede = 1',
			array('utilisateur_id' => $id)
		);

		$edition_ids=split(',',$editions[0][0]['edition_ids']);

		$conditions = array(
				'Edition.id' => $edition_ids
		);
		$this->Paginator->settings = array(
			'recursive' => 2 ,
			'contain' => array('Exemplaire','Exemplaire.Utilisateur','Livre','Editeur','Livre.Auteur'),
			'conditions' => $conditions ,
			'limit' => 10
		);
		$this->set('title_page', 'Bibliothèque de '.$utilisateur['Utilisateur']['nom_utilisateur']);
		/* On passe les éditions trouvées à la vue */
		$this->set('editions', $this->Paginator->paginate('Edition'));
		/* On appelle maintenant la vue index.ctp */
		$this->render('index');
	}	
/**
 * user_index method
 * Affiche la bibliothèque de l'utilisateur connectée
 * accessible uniquement quand on est connecté
 * @return void
 */
	public function user_index() {
		/* On unbind Exemplaire tq défini dans le model */
		$this->Edition->unbindModel(
			array('hasMany' => array('Exemplaire')), false
		);
		/* On lie Edition à un seul exemplaire, celui de l'utilisateur connecté */
		$this->Edition->bindModel(
			array('hasOne' => array('Exemplaire')) , false
		);
		
		$this->Paginator->settings = array(
			'recursive' => 2 ,
			'contain' => array('Exemplaire','Livre','Editeur','Livre.Auteur'),
			'conditions' => array('Exemplaire.utilisateur_id = ' => $this->Auth->user('id')),
			'limit' => 20
		);		
		
		$this->set('editions', $this->Paginator->paginate('Edition'));
	}
/**
 * add_multiple method
 * Ajoute dans la bibliothèque d'un utilisateur les livres qu'il a cochés
 * @return void
 */
	public function add_multiple() {
		/* Si des paramètres sont passés en POST 
		=> l'utilisateur ajoute des livres dans sa bibliothèque */
		if ($this->request->is('post')) {
			foreach($this->request->data['Edition'] as $edition_id){
				if(!$edition_id) continue;
				$data = array();
				$this->Exemplaire->create();
				$data['Exemplaire']['edition_id']= $edition_id;
				$data['Exemplaire']['utilisateur_id']= $this->Auth->user('id');
				$this->Exemplaire->recursive = -1;
				$exemplaire = $this->Exemplaire->find('first',array('conditions'=>$data['Exemplaire']));
				if($exemplaire) $data = $exemplaire;
				$data['Exemplaire']['possede']= 1;
				if ($this->Exemplaire->save($data)) {
					$this->Session->setFlash(__('Les livres ont été ajoutés dans votre bibliothèque.'));
					//return $this->redirect(array('action' => 'index'));
				} else {
					$this->Session->setFlash(__('Erreur lors de l\'enregistrement.'));
				}
			}
		} 
		/* Si des paramètres sont passés en GET 
		=> l'utilisateur fait une recherche de livres à ajouter */		
		elseif (isset($this->request->query['search'])){
			$utilidateur_id = $this->Auth->user('id');
			/* latitude de l'utilisateur */
			$latitude =  AuthComponent::user('latitude');
			/* longitude de l'utilisateur */
			$longitude =  AuthComponent::user('longitude');
			/* fragment de requete sql permettant de calculer 
			   la distance entre un exemplaire et l'utilisateur connecté */
			$distance_sql = "( 6371 * acos( cos( radians($latitude) ) * cos( radians( latitude ) ) * cos( radians(longitude ) - radians($longitude) ) + sin( radians($latitude) ) * sin( radians(latitude ) ) ) ) as `distance`";			
			/* Mots-clés recherchés */
			$search = $this->request->query['search'];
			/* On va importer les livres depuis google books*/
			$this->addLivresFromGoogle();
			
			/* Est-ce que la recherche est un ISBN ? */
			$isbn = ereg_replace("[^0-9]","",$search);
			
			if(strlen($search) < 18 && strlen($isbn)>8) {
				$conditions = array('or' => array(
									'Edition.isbn10 LIKE' => '%'.$isbn.'%',
									'Edition.isbn13 LIKE' => '%'.$isbn.'%'
									)
								);
			} else {
				$conditions = array('or' => array(
									'Livre.titre LIKE' => '%'.$search.'%',
									'Livre.sous_titre LIKE' => '%'.$search.'%',
									'Livre.auteurs LIKE' => '%'.$search.'%',
									'Livre.resume LIKE' => '%'.$search.'%',
									'Edition.isbn10 LIKE' => '%'.substr(ereg_replace("[^0-9]","",$search),0,-1).'%',
									'Edition.isbn13 LIKE' => '%'.substr($search,0,-2).'%'
								));
			}		
			/* On lie Edition via 1 requête aux exemplaires disponibles */
			$this->Edition->bindModel(
				array('hasMany' => array(
						'ExemplaireDisponible' => array(
							'className' => 'Exemplaire',
							'finderQuery' => ' SELECT ExemplaireDisponible.* from 
							(select exemplaires.*, '.$distance_sql.' from exemplaires, utilisateurs WHERE exemplaires.utilisateur_id = utilisateurs.id
								and exemplaires.edition_id in ({$__cakeID__$}) ) as ExemplaireDisponible order by ExemplaireDisponible.distance asc 
								'
						)
					)
				)
			);
			/* On lie Edition à l'exemeplaire de l'utilisateur connecté s'il en a un */
			$this->Edition->bindModel(
				array('hasOne' => array(
						'ExemplaireUtilisateur' => array(
							'className' => 'Exemplaire',
							'conditions' => 'ExemplaireUtilisateur.utilisateur_id='.$utilidateur_id
						)
					)
				)
			);			
			$this->Paginator->settings = array(
				'recursive' => 2 ,
				'conditions' => $conditions ,
				'limit' => 20,
				'contain' => array('Exemplaire','Livre','Editeur','Livre.Auteur','Livre.LivresTagsCategory.TagsCategory','ExemplaireUtilisateur','ExemplaireDisponible','ExemplaireDisponible.Utilisateur')
			);		

			$editions = $this->Paginator->paginate('Edition');
			$this->set('editions', $editions);	
		} 
		
		
		
	}
/**
 * add_multiple_ajax method
 *
 * @return void
 */
	public function addLivresFromGoogle() {

		if ($this->request->is('get')) {

			$search = $this->request->query['search'];
			/* On soumet la requête de recherche à Google Book qui va nous répondre au format JSON */
			$resultatJson = file_get_contents("https://www.googleapis.com/books/v1/volumes?q=".urlencode($search).'&maxResults=40&printType=books');
			
			/* On convertit la réponse JSON en tableau qui sera plus facile à traiter en PHP */
			$resultatArray = json_decode($resultatJson,true);
			/* Si la réponse ne comporte pas d'item, on sort */
			if(!isset($resultatArray['items'])) return;
			/* Sinon on boucle sur les items retournées */
			foreach($resultatArray['items'] as $key => $item){
				
				/* déclaration de variables vides que l'on va remplir avec les données à sauvegarder */
				$data = array();
				$data['Livre'] = array();
				$data['Livre']['auteurs'] = "";
				$data['Edition'] = array();
				$edition = array();
				$data['TagsCategory'] = array();
				
				$data['Livre']['titre'] = $item['volumeInfo']['title'];
				
				if(isset($item['volumeInfo']['subtitle']))
					$data['Livre']['sous_titre'] = $item['volumeInfo']['subtitle'];
				else
					$data['Livre']['sous_titre'] = "";
				
				if(isset($item['volumeInfo']['description'])){
					$data['Livre']['resume'] = $item['volumeInfo']['description'];
				}
				
				/* Si pas d'éditeur renseigné, on met éditeur à Inconnu */				
				if(!isset($item['volumeInfo']['publisher'])){
					$item['volumeInfo']['publisher'] = 'Inconnu';
				}

				$editeur = $this->Editeur->find('first',array(
					'conditions'=>array('nom'=>$item['volumeInfo']['publisher']))
					);
				/* Si l'editeur n'existe pas , il sera créé lors de la sauvegarde du livre */
				if(empty($editeur)) {
					$edition['Editeur']=array('nom'=>$item['volumeInfo']['publisher']);
				} else {
					$edition['Editeur']=$editeur;
				}
				/* Si pas d'auteur renseigné, on valorise auteur à Inconnu */
				if(!isset($item['volumeInfo']['authors'])){
					$item['volumeInfo']['authors'] = array('Inconnu');
				}
			
				/* Liste des auteurs à associer au livre */
				$data['Auteur'] = array();
				foreach($item['volumeInfo']['authors'] as $name){
					$data['Livre']['auteurs'] .= $name." ";
					$auteur = $this->Auteur->find('first',array(
						'conditions'=>array('prenom_nom'=>$name))
						);
					/* Si l'auteur n'existe pas , on le crée */
					if(empty($auteur)) {
						$this->Auteur->create();
						$this->Auteur->save(array('prenom_nom'=>$name));
						$data['Auteur'][]=$this->Auteur->id;
					} else {
						$data['Auteur'][]=$auteur['Auteur']['id'];
					}						
				}
				
				if(isset($item['volumeInfo']['mainCategory'])){
					$this->TagsCategory->locale = 'eng';
					$tag=$this->TagsCategory->find('first',array('conditions'=>array('libelle'=>$item['volumeInfo']['mainCategory'])));
					if(empty($tag)){
						$this->TagsCategory->create();
						$this->TagsCategory->save(array('libelle'=>$item['volumeInfo']['mainCategory']));
						$data['TagsCategory'][]=$this->TagsCategory->id;
					} else {
						$data['TagsCategory'][]=$tag['TagsCategory']['id'];
					}
				}
				
				if(isset($item['volumeInfo']['categories'])){
					foreach($item['volumeInfo']['categories'] as $category){
						$this->TagsCategory->locale = 'eng';
						$tag=$this->TagsCategory->find('first',array('conditions'=>array('libelle'=> $category)));
						if(empty($tag)){
							$this->TagsCategory->create();
							$this->TagsCategory->save(array('libelle'=> $category));
							$data['TagsCategory'][]=$this->TagsCategory->id;
						} else {
							$data['TagsCategory'][]=$tag['TagsCategory']['id'];
						}						
					}
				}
				
				if(isset($item['volumeInfo']['publishedDate'])){
					$datePublication = explode('-',$item['volumeInfo']['publishedDate']);
					switch(count($datePublication)){
						case 3 :
							$edition['annee'] = $datePublication[0];
							$edition['mois'] = $datePublication[1];
							$edition['jour'] = $datePublication[2];
							break;
						case 2 :
							$edition['annee'] = $datePublication[0];
							$edition['mois'] = $datePublication[1];
							break;
						case 1 :
							$edition['annee'] = $datePublication[0];
							break;
					}
				}
				
				if(isset($item['volumeInfo']['industryIdentifiers'])){
					foreach($item['volumeInfo']['industryIdentifiers'] as $isbn){
						if($isbn['type']=='ISBN_13') $edition['isbn13'] = $isbn['identifier'];
						if($isbn['type']=='ISBN_10') $edition['isbn10'] = $isbn['identifier'];
					}
				}
				/* On vérifie si un livre avec le même titre et sous-titre existe déjà */
				$livre = $this->Livre->find('first',array(
					'conditions'=>array(
						'titre'=>$data['Livre']['titre'],
						'sous_titre'=>$data['Livre']['sous_titre']
						)
					)
				);
				/* Si le livre existe, on cherche si l'édition renvoyée par google books existe elle aussi 
				Condition d'existance d'une édition : sur l'isbn ou l'éditeur
				*/
				if(!empty($livre)){
					$edition_existante = array();
					$data['Livre']['id'] = $livre['Livre']['id'];
					if(isset($editeur['Editeur']['id']) && isset($edition['isbn13'])){
						if( $edition['isbn13']!='') 
							$edition_existante = $this->Edition->find('first',array(
								'conditions'=>array('livre_id'=> $data['Livre']['id'],
													'editeur_id'=>$editeur['Editeur']['id'],
													'isbn13' => $edition['isbn13'] 
													))
								);
						else {
							$edition_existante = $this->Edition->find('first',array(
								'conditions'=>array('livre_id'=> $data['Livre']['id'],
													'editeur_id'=>$editeur['Editeur']['id']
													))
								);							
						}
						if(!empty($edition_existante))
							$edition['id'] = $edition_existante['Edition']['id'];
					}
				}
				
				$data['Edition'][]=$edition;
				$this->Livre->recursive = 1;
				$this->Livre->create();
				/* On sauvegarde le livre et tous ses modèles liés */
				if ($this->Livre->saveAssociated($data,array('deep'=>true))) {
					$edition_id = $this->Livre->Edition->getLastInsertID();
					if(isset($item['volumeInfo']['imageLinks']['thumbnail']) && $edition_id){
						$fichier = IMAGES.'livres'.DIRECTORY_SEPARATOR.$edition_id.'.jpg';
						/* Si on a l'url de l'image on la sauvegarde et met à jour la base */
						copy($item['volumeInfo']['imageLinks']['thumbnail'], $fichier);
						$data['Edition']['image'] = $edition_id.'.jpg';
						$this->Edition->save($data);
					}
				}				
			}
		}
		
	/* On rend la main à la fonction appelante */	
		
	}
/**
 * view method
 *
 * @throws NotFoundException
 * @param string $id : lid de l'édition à visualiser
 * @return void
 */
	public function view($id = null) {
		/* Si l'édition n'existe pas, on lève une Exception */
		if (!$this->Edition->exists($id)) {
			throw new NotFoundException(__('Livre inconnu.'));
		}
		/* on met la profondeur de recherche à 2 (pour aller chercher les auteurs qui sont liés à Livre ) */
		$this->Edition->recursive = 2;

		$this->Auteur->recursive=0;
		
		/* Si l'utilisateur est connecté :
		   On affichera les exemplaires et leur distance par rapport à l'utilisateur connecté
		*/
		if($this->Auth->login()){
			$utilidateur_id = $this->Auth->user('id');
			$latitude =  AuthComponent::user('latitude');
			$longitude =  AuthComponent::user('longitude');
			$distance_sql = "( 6371 * acos( cos( radians($latitude) ) * cos( radians( latitude ) ) * cos( radians(longitude ) - radians($longitude) ) + sin( radians($latitude) ) * sin( radians(latitude ) ) ) ) as `distance`";
		} else {
			$utilidateur_id = 0;
			$distance_sql = "'' as distance";
		}
		
		/* On lie Edition via 1 requête aux exemplaires disponibles */
		$this->Edition->bindModel(
			array('hasMany' => array(
					'ExemplaireDisponible' => array(
						'className' => 'Exemplaire',
						'finderQuery' => ' SELECT ExemplaireDisponible.* from 
						(select exemplaires.*, '.$distance_sql.' from exemplaires, utilisateurs WHERE exemplaires.utilisateur_id = utilisateurs.id
							and exemplaires.edition_id in ({$__cakeID__$}) ) as ExemplaireDisponible order by ExemplaireDisponible.distance asc 
							'
					)
				)
			)
		);
		/* On lie Edition à l'exemeplaire de l'utilisateur connecté s'il en a un */
		$this->Edition->bindModel(
			array('hasOne' => array(
					'ExemplaireUtilisateur' => array(
						'className' => 'Exemplaire',
						'conditions' => 'ExemplaireUtilisateur.utilisateur_id='.$utilidateur_id
					)
				)
			)
		);
		
		/* Recherche des items à mettre dans la colone de gauche dans la vue */
		if(!isset($this->viewVars['auteurs'])){
			$this->set('auteurs',$this->Auteur->getPopulaires());
		}
		if(!isset($this->viewVars['categories'])){
			$this->set('categories',$this->TagsCategory->getPopulaires());
		}
		
		$options = array('conditions' => array('Edition.' . $this->Edition->primaryKey => $id));
		/* Recherche du livre et passage dans la vue */
		$this->set('edition', $this->Edition->find('first', $options));
	}

/**
 * add method
 * Fonction non implémentée
 * @return void
 */
	public function add() {
		
		throw new NotFoundException(__('Page inexistante.'));
		
		if ($this->request->is('post')) {
			$this->Edition->create();
			if ($this->Edition->save($this->request->data)) {
				$this->Session->setFlash(__('L\'édition a été enregistrée.'));
				return $this->redirect(array('action' => 'index'));
			} else {
				$this->Session->setFlash(__('The edition could not be saved. Please, try again.'));
			}
		}
		$livres = $this->Edition->Livre->find('list');
		$editeurs = $this->Edition->Editeur->find('list');
		$this->set(compact('livres', 'editeurs'));
	}

/**
 * edit method
 * Permet de modifier les informations d'un livre
 * @throws NotFoundException
 * @param string $id : l'id de l'édition à éditer
 * @return void
 */
	public function edit($id = null) {

		if (!$this->Edition->exists($id)) {
			throw new NotFoundException(__('Livre inconnu'));
		}
		$this->Edition->recursive=2;
		
		/* Ici on veut qu'une édition n'est qu'un exemplaire : celui de l'utilisateur connecté */
		$this->Edition->unbindModel(
			array('hasMany' => array('Exemplaire')), false
		);
		$this->Edition->bindModel(
			array('hasOne' => array('Exemplaire')) , false
		);
		
		/* Si params passés en post, on sauvegarde */
		if ($this->request->is(array('post', 'put'))) {
	
			if ($this->Edition->saveAll($this->request->data,array('deep'=>true))) {
				$this->Session->setFlash(__('L\'édition a été enregistrée.'));
				return $this->redirect(array('action' => 'user_index'));
			} else {
				$this->Session->setFlash(__('The edition could not be saved. Please, try again.'));
			}
		} else {
			$options = array('conditions' => array('Edition.' . $this->Edition->primaryKey => $id),
							'contain' => array('Exemplaire','Livre','Editeur','Livre.Auteur'));
			$this->request->data = $this->Edition->find('first', $options);
		}

	}
	
}
